type github.com/refraction-networking/utls.clientHelloMsg

55 uses

	github.com/refraction-networking/utls (current package)
		conn.go#L1124: 		m = new(clientHelloMsg)
		ech.go#L211: func encodeInnerClientHello(inner *clientHelloMsg, maxNameLength int) ([]byte, error) {
		ech.go#L218: func encodeInnerClientHelloReorderOuterExts(inner *clientHelloMsg, maxNameLength int, outerExts []uint16) ([]byte, error) { // uTLS
		ech.go#L257: func extractRawExtensions(hello *clientHelloMsg) ([]rawExtension, error) {
		ech.go#L283: func decodeInnerClientHello(outer *clientHelloMsg, encoded []byte) (*clientHelloMsg, error) {
		ech.go#L384: 	inner := &clientHelloMsg{}
		ech.go#L416: func computeAndUpdateOuterECHExtension(outer, inner *clientHelloMsg, ech *echClientContext, useKey bool) error {
		ech.go#L559: func (c *Conn) processECHClientHello(outer *clientHelloMsg) (*clientHelloMsg, *echServerContext, error) {
		handshake_client.go#L36: 	hello        *clientHelloMsg
		handshake_client.go#L48: func (c *Conn) makeClientHello() (*clientHelloMsg, *keySharePrivateKeys, *echClientContext, error) {
		handshake_client.go#L75: 	hello := &clientHelloMsg{
		handshake_client.go#L262: 	innerHello      *clientHelloMsg
		handshake_client.go#L396: func (c *Conn) loadSession(hello *clientHelloMsg) (
		handshake_client.go#L1362: func computeAndUpdatePSK(m *clientHelloMsg, binderKey []byte, transcript hash.Hash, finishedHash func([]byte, hash.Hash) []byte) error {
		handshake_client_tls13.go#L30: 	hello        *clientHelloMsg
		handshake_messages.go#L71: type clientHelloMsg struct {
		handshake_messages.go#L108: func (m *clientHelloMsg) marshalMsg(echInner bool) ([]byte, error) {
		handshake_messages.go#L113: func (m *clientHelloMsg) marshalMsgReorderOuterExts(echInner bool, outerExts []uint16) ([]byte, error) {
		handshake_messages.go#L400: func (m *clientHelloMsg) marshal() ([]byte, error) {
		handshake_messages.go#L413: func (m *clientHelloMsg) marshalWithoutBinders() ([]byte, error) {
		handshake_messages.go#L435: func (m *clientHelloMsg) updateBinders(pskBinders [][]byte) error {
		handshake_messages.go#L449: func (m *clientHelloMsg) unmarshal(data []byte) bool {
		handshake_messages.go#L450: 	*m = clientHelloMsg{original: data}
		handshake_messages.go#L713: func (m *clientHelloMsg) originalBytes() []byte {
		handshake_messages.go#L717: func (m *clientHelloMsg) clone() *clientHelloMsg {
		handshake_messages.go#L718: 	return &clientHelloMsg{
		handshake_server.go#L29: 	clientHello  *clientHelloMsg
		handshake_server.go#L136: func (c *Conn) readClientHello(ctx context.Context) (*clientHelloMsg, *echServerContext, error) {
		handshake_server.go#L143: 	clientHello, ok := msg.(*clientHelloMsg)
		handshake_server.go#L990: func clientHelloInfo(ctx context.Context, c *Conn, clientHello *clientHelloMsg) *ClientHelloInfo {
		handshake_server_tls13.go#L48: 	clientHello     *clientHelloMsg
		handshake_server_tls13.go#L599: 	clientHello, ok := msg.(*clientHelloMsg)
		handshake_server_tls13.go#L673: func illegalClientHelloChange(ch, ch1 *clientHelloMsg) bool {
		key_agreement.go#L27: 	generateServerKeyExchange(*Config, *Certificate, *clientHelloMsg, *serverHelloMsg) (*serverKeyExchangeMsg, error)
		key_agreement.go#L34: 	processServerKeyExchange(*Config, *clientHelloMsg, *serverHelloMsg, *x509.Certificate, *serverKeyExchangeMsg) error
		key_agreement.go#L35: 	generateClientKeyExchange(*Config, *clientHelloMsg, *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error)
		key_agreement.go#L45: func (ka rsaKeyAgreement) generateServerKeyExchange(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg) (*serverKeyExchangeMsg, error) {
		key_agreement.go#L77: func (ka rsaKeyAgreement) processServerKeyExchange(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, skx *serverKeyExchangeMsg) error {
		key_agreement.go#L81: func (ka rsaKeyAgreement) generateClientKeyExchange(config *Config, clientHello *clientHelloMsg, cert *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error) {
		key_agreement.go#L169: func (ka *ecdheKeyAgreement) generateServerKeyExchange(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg) (*serverKeyExchangeMsg, error) {
		key_agreement.go#L275: func (ka *ecdheKeyAgreement) processServerKeyExchange(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, skx *serverKeyExchangeMsg) error {
		key_agreement.go#L360: func (ka *ecdheKeyAgreement) generateClientKeyExchange(config *Config, clientHello *clientHelloMsg, cert *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error) {
		u_conn.go#L506: func (uconn *UConn) computeAndUpdateOuterECHExtension(inner *clientHelloMsg, ech *echClientContext, useKey bool) error {
		u_handshake_client.go#L170: func (c *Conn) makeClientHelloForApplyPreset() (*clientHelloMsg, *keySharePrivateKeys, *echClientContext, error) {
		u_handshake_client.go#L197: 	hello := &clientHelloMsg{
		u_handshake_client.go#L577: func (c *UConn) echTranscriptMsg(outer *clientHelloMsg, echCtx *echClientContext) (err error) {
		u_public.go#L387: 	cachedPrivateHello   *clientHelloMsg // todo: further optimize to reduce clientHelloMsg construction
		u_public.go#L391: func (chm *PubClientHelloMsg) getPrivatePtr() *clientHelloMsg {
		u_public.go#L395: 		private := &clientHelloMsg{
		u_public.go#L433: func (chm *PubClientHelloMsg) getCachedPrivatePtr() *clientHelloMsg {
		u_public.go#L441: func (chm *clientHelloMsg) getPublicPtr() *PubClientHelloMsg {
		u_public.go#L484: 	m := &clientHelloMsg{}